home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / c / pdc / libr / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-19  |  9.9 KB  |  412 lines
  1.  
  2. #include "dolib.h"
  3.  
  4. char           *progname;
  5.  
  6. extern int      optind;
  7. extern int      opterr;
  8. extern FILE    *efopen();
  9. extern char    *malloc();
  10.  
  11. int             a_flag;
  12. int             d_flag;
  13. int             l_flag;
  14. int             r_flag;
  15. int             v_flag;
  16. int             x_flag;
  17.  
  18. LL             *objhead, *objtail;
  19.  
  20. char            libname[80];    /* name of the library file  */
  21. FILE           *libfp;
  22. char            dirname[80];    /* name of the directory file */
  23. FILE           *dirfp;
  24. char            objname[80];    /* name of current object file */
  25. FILE           *objfp;
  26.  
  27. void
  28. makename(buffer, name, ext)
  29.     char           *buffer, *name, *ext;
  30. {
  31.     while (*name && *name != '.')
  32.         *buffer++ = *name++;
  33.     while (*ext)
  34.         *buffer++ = *ext++;
  35.     *buffer = '\0';
  36. }
  37.  
  38. list_library()
  39. {
  40.     LD              d_entry;
  41.     int             count;
  42.     int             bytes;
  43.  
  44.     if ((dirfp = fopen(dirname, "r")) == NULL) {
  45.         printf("%s not found\n", dirname);
  46.         exit(1);
  47.     }
  48.     printf("Directory of library %s\n\n", libname);
  49.     printf("Module Name                    Size   Offset\n");
  50.     count = bytes = 0;
  51.     while (fread((char *) &d_entry, 1, sizeof(LD), dirfp) == sizeof(LD)) {
  52.         printf("%-30.30s %-6d %-6d\n", d_entry.object_filename,
  53.                d_entry.module_size, d_entry.module_offset);
  54.         count++;
  55.         bytes += d_entry.module_size;
  56.     }
  57.     printf("\nLibrary consists of %d entries totaling %d bytes\n",
  58.            count, bytes);
  59.     fclose(dirfp);
  60. }
  61.  
  62. read_library()
  63. {
  64.     LL             *lp; /* pointer to the load module */
  65.     int             rc;
  66.  
  67.     objhead = objtail = NULL;
  68.  
  69.     /*
  70.      * Open the library and directory files
  71.      */
  72.     if ((libfp = fopen(libname, "r")) == NULL)
  73.         return;
  74.     if ((dirfp = fopen(dirname, "r")) == NULL) {
  75.         printf("%s has been corrupted\n", dirname);
  76.         exit(1);
  77.     }
  78.  
  79.     /*
  80.      * The files are now open, read in the library
  81.      */
  82.     for (;;) {
  83.  
  84.         /*
  85.          * Allocate a node to hold the object module
  86.          */
  87.         lp = (LL *) malloc(sizeof(LL));
  88.         if (lp == NULL) {
  89.             printf("Not enough memory\n");
  90.             exit(1);
  91.         }
  92.  
  93.         /*
  94.          * Check for end of file
  95.          */
  96.         rc = fread((char *) &lp->dir_entry, 1, sizeof(LD), dirfp);
  97.         if (rc != sizeof(LD))
  98.             break;
  99.  
  100.         /*
  101.          * Allocate a buffer to hold the object file image.
  102.          */
  103.         lp->object_module = (char *) malloc(lp->dir_entry.module_size);
  104.         if (lp->object_module == NULL) {
  105.             printf("Not enough memory.\n");
  106.             exit(1);
  107.         }
  108.  
  109.         /*
  110.          * Read in the object module
  111.          */
  112.         rc = fread(lp->object_module, 1, lp->dir_entry.module_size, libfp);
  113.         if (rc != lp->dir_entry.module_size) {
  114.             printf("Library file is corrupted.\n");
  115.             exit(1);
  116.         }
  117.  
  118.         /*
  119.          * Add the module to the linked list
  120.          */
  121.         lp->next = NULL;
  122.         if (objhead == NULL)
  123.             objhead = objtail = lp;
  124.         else
  125.             objtail->next = lp;
  126.         while (objtail->next != NULL)
  127.             objtail = objtail->next;
  128.     }
  129.  
  130.     /*
  131.      * Library has been read in ok.  Close the files and return
  132.      */
  133.     fclose(libfp);
  134.     fclose(dirfp);
  135.     return (FALSE);
  136. }
  137.  
  138. write_library()
  139. {
  140.     LL             *lp;
  141.     long            file_position;
  142.     long            len, rc;
  143.  
  144.     /*
  145.      * Open the library
  146.      */
  147.     if ((libfp = fopen(libname, "w")) == NULL) {
  148.         printf("Error opening %s for output\n", libname);
  149.         exit(1);
  150.     }
  151.     if ((dirfp = fopen(dirname, "w")) == NULL) {
  152.         printf("Error opening %s for output\n", dirname);
  153.         exit(1);
  154.     }
  155.  
  156.     /*
  157.      * Write out the individual modules and directory records.
  158.      */
  159.     file_position = 0;
  160.     for (lp = objhead; lp != NULL; lp = lp->next) {
  161.         len = fwrite(lp->object_module, 1, lp->dir_entry.module_size, libfp);
  162.         if (len != lp->dir_entry.module_size) {
  163.             printf("Error writing to library file\n");
  164.             exit(1);
  165.         }
  166.         lp->dir_entry.module_offset = file_position;
  167.         file_position += len;
  168.         rc = fwrite((char *) &lp->dir_entry, 1, sizeof(LD), dirfp);
  169.         if (rc != sizeof(LD)) {
  170.             printf("Error writing to directory file\n");
  171.             exit(1);
  172.         }
  173.     }
  174.  
  175.     /*
  176.      * Close the library files
  177.      */
  178.     fclose(libfp);
  179.     fclose(dirfp);
  180.     printf("library is %d bytes\n", file_position);
  181. }
  182.  
  183. LL             *
  184. search()
  185. {
  186.     LL             *lp;
  187.  
  188.     for (lp = objhead; lp != NULL; lp = lp->next) {
  189.         if (strcmp(lp->dir_entry.object_filename, objname) == 0)
  190.             return (lp);
  191.     }
  192.     return (NULL);
  193. }
  194.  
  195. delete_library(name)
  196.     char           *name;
  197. {
  198.     LL             *lp, *lp2;
  199.  
  200.     makename(objname, name, ".o");
  201.     lp = objhead;
  202.     if (strcmp(lp->dir_entry.object_filename, objname) == 0) {
  203.         free(lp->object_module);
  204.         objhead = objtail = lp->next;
  205.         if (objtail) {
  206.             while (objtail->next != NULL)
  207.                 objtail = objtail->next;
  208.         }
  209.         printf("%s deleted\n", objname);
  210.         return (TRUE);
  211.     }
  212.     lp2 = objhead;
  213.     for (lp = objhead; lp != NULL; lp = lp->next) {
  214.         if (strcmp(lp->dir_entry.object_filename, objname) == 0) {
  215.             free(lp->object_module);
  216.             lp2->next = lp->next;
  217.             objtail = objhead;
  218.             if (objtail) {
  219.                 while (objtail->next != NULL)
  220.                     objtail = objtail->next;
  221.             }
  222.             printf("%s deleted\n", objname);
  223.             return (TRUE);
  224.         }
  225.         lp2 = lp;
  226.     }
  227.     return (FALSE);
  228. }
  229.  
  230. add_library(name)
  231.     char           *name;
  232. {
  233.     LL             *lp;
  234.     int             rc, new;
  235.  
  236.     makename(objname, name, ".o");
  237.  
  238.     /*
  239.      * Open the object file
  240.      */
  241.     if ((objfp = fopen(objname, "r")) == NULL) {
  242.         printf("%s cannot be added\n", objname);
  243.         exit(1);
  244.     }
  245.  
  246.     /*
  247.      * See if we are replacing an old copy
  248.      */
  249.     lp = search();
  250.     if (!(new = (lp == NULL))) {
  251.         free(lp->object_module);
  252.         lp->object_module = NULL;
  253.     }
  254.     else {
  255.  
  256.         /*
  257.          * Allocate a node to hold the file.
  258.          */
  259.         if ((lp = (LL *) malloc(sizeof(LL))) == NULL) {
  260.             printf("Not enough memory.\n");
  261.             exit(1);
  262.         }
  263.  
  264.         /*
  265.          * Initialize it.
  266.          */
  267.         strcpy(lp->dir_entry.object_filename, objname);
  268.     }
  269.     fseek(objfp, 0L, 2);
  270.     lp->dir_entry.module_size = ftell(objfp);
  271.     fseek(objfp, 0L, 0);
  272.  
  273.     /*
  274.      * Allocate the buffer to read the object module into.
  275.      */
  276.     lp->object_module = (char *) malloc(lp->dir_entry.module_size);
  277.     if (lp->object_module == NULL) {
  278.         printf("Not enough memory.\n");
  279.         exit(1);
  280.     }
  281.  
  282.     /*
  283.      * Read in the file.
  284.      */
  285.     rc = fread(lp->object_module, 1, lp->dir_entry.module_size, objfp);
  286.     if (rc != lp->dir_entry.module_size) {
  287.         printf("Library file is corrupted.\n");
  288.         exit(1);
  289.     }
  290.  
  291.     /*
  292.      * Add module to linked list.
  293.      */
  294.     if (new) {
  295.         lp->next = NULL;
  296.         if (objhead == NULL)
  297.             objhead = objtail = lp;
  298.         else
  299.             objtail->next = lp;
  300.         while (objtail->next != NULL)
  301.             objtail = objtail->next;
  302.     }
  303.  
  304.     /*
  305.      * Close object file and return.
  306.      */
  307.     fclose(objfp);
  308.     printf("%s added, size = %d\n", name, lp->dir_entry.module_size);
  309. }
  310.  
  311. usage()
  312. {
  313.     printf("Usage: %s [ -adlrx ] <Library> [ file ... ]\n", progname);
  314.     printf("\t-a:\tAdd files to the library.\n");
  315.     printf("\t-d:\tDelete files from the library.\n");
  316.     printf("\t-l:\tList the library.\n");
  317.     printf("\t-r:\tReplace files in the library.\n");
  318.     printf("\t-x:\tSort modules for one-pass linker.\n");
  319.     exit(1);
  320. }
  321.  
  322. main(argc, argv)
  323.     int             argc;
  324.     char           *argv[];
  325.  
  326. {
  327.     FILE           *inp;
  328.     int             c;
  329.     int             i;
  330.     FILE           *fp;
  331.  
  332.     opterr = 1;
  333.     progname = argv[0];
  334.     a_flag = d_flag = l_flag = r_flag = v_flag = x_flag = FALSE;
  335.     while ((c = getopt(argc, argv, "adlrvx")) != EOF) {
  336.         switch (c) {
  337.         case 'a':
  338.             a_flag = TRUE;
  339.             if (l_flag || d_flag || r_flag)
  340.                 usage();
  341.             break;
  342.         case 'd':
  343.             d_flag = TRUE;
  344.             if (r_flag || l_flag || a_flag)
  345.                 usage();
  346.             break;
  347.         case 'l':
  348.             l_flag = TRUE;
  349.             if (d_flag || x_flag || r_flag || a_flag)
  350.                 usage();
  351.             break;
  352.         case 'r':
  353.             r_flag = TRUE;
  354.             if (l_flag || d_flag || a_flag)
  355.                 usage();
  356.             break;
  357.         case 'v':
  358.             v_flag = TRUE;
  359.             break;
  360.         case 'x':
  361.             x_flag = TRUE;
  362.             if (l_flag)
  363.                 usage();
  364.             break;
  365.         case '?':
  366.             usage();
  367.             break;
  368.         }
  369.     }
  370.  
  371.     if (!(a_flag || r_flag || d_flag || l_flag || x_flag))
  372.         usage();
  373.  
  374.     argc -= optind;
  375.     argv += optind;
  376.  
  377.     if (l_flag) {       /* directory listing */
  378.         if (argc != 1)
  379.             usage();
  380.         else {
  381.             makename(libname, argv[0], ".lib");
  382.             makename(dirname, argv[0], ".dir");
  383.             list_library();
  384.         }
  385.     }
  386.     else {
  387.         if (argc == 0)
  388.             usage();
  389.         else {
  390.             makename(libname, argv[0], ".lib");
  391.             makename(dirname, argv[0], ".dir");
  392.             read_library();
  393.             for (i = 1; i < argc; i++) {
  394.                 if (a_flag) {
  395.                     delete_library(argv[i]);
  396.                     add_library(argv[i]);
  397.                 }
  398.                 else if (r_flag)
  399.                     add_library(argv[i]);
  400.                 else if (d_flag)
  401.                     delete_library(argv[i]);
  402.             }
  403.             if (x_flag) {
  404.                 topsort();
  405.                 printf("%s cross-referenced.\n", libname);
  406.             }
  407.             write_library();
  408.         }
  409.     }
  410.     exit(0);
  411. }
  412.